﻿using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace KATAJAVI_SIA
{
    public partial class AgregarMotos : Form
    {
        KATAJAVI call = new KATAJAVI();
        DataClassesDataContext BEDE = new DataClassesDataContext();
        IEnumerable<MARCA_MOTO> lista;
        IEnumerable<CLIENTE> lista1;
        int valpatente, valmod, valrut, valdueno, valmarca, valcolor;

        public AgregarMotos()
        {
            InitializeComponent();
        }

        private void AgregarMotos_Load(object sender, EventArgs e)
        {
            lista = BEDE.MARCA_MOTO.OrderBy(a => a.Nombre).Where(a => a.id_marca != 0);
            cbx_MotoMarca.DataSource = lista;
            cbx_MotoMarca.ValueMember = "id_marca" ;
            cbx_MotoMarca.DisplayMember = "Nombre";
            cbx_MotoColor.SelectedIndex = -1;
            cbx_MotoMarca.SelectedIndex = -1;
            int aa = cbx_MotoMarca.Items.Count;
            if (aa == 0)
            {
                tbx_MotoPatente.Enabled = false;
                cbx_MotoMarca.Enabled = false;
                tbx_MotoRutDueno.Enabled = false;
                tbx_MotoRutDigitoDueno.Enabled = false;
                tbx_MotoNombreDueno.Enabled = false;
                tbx_MotoModelo.Enabled = false;
                cbx_MotoColor.Enabled = false;
                btn_MotoGuardar.Enabled = false;
                btn_MotoLimpiar.Enabled = false;
                MessageBox.Show("El sistema no puede comenzar a registrar motocicletas mientras no se registre, a lo menos, una marca. Por favor ingrese al panel de administración, y registre alguna marca antes de comensar a registrar mococicletas.", "ERROR AL INICIAR REGISTROS", MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }
        }

        private void Limpiar()
        {
            tbx_MotoPatente.Clear();
            tbx_MotoModelo.Clear();
            tbx_MotoRutDueno.Clear();
            cbx_MotoColor.SelectedIndex = 0;
            cbx_MotoMarca.SelectedIndex = 0;
            btn_MotoGuardarLink.Enabled = false;
            cbx_MotoColor.SelectedIndex = -1;
            cbx_MotoMarca.SelectedIndex = -1;
            errorProvider1.Clear();
            tbx_MotoNombreDueno.Clear();
            tbx_MotoRutDigitoDueno.Clear();
        }
        private void btn_ClienteLimpiar_Click_1(object sender, EventArgs e)
        {
            Limpiar();
        }

        private void tbx_MotoPatente_TextChanged(object sender, EventArgs e)
        {
            tbx_MotoPatente.Text = tbx_MotoPatente.Text.Trim();
        }

        private void btn_MotoGuardar_Click(object sender, EventArgs e)
        {
            try
            {
                tbx_MotoPatente.Focus();
                cbx_MotoMarca.Focus();
                tbx_MotoRutDigitoDueno.Focus();
                tbx_MotoModelo.Focus();
                cbx_MotoColor.Focus();
                tbx_MotoPatente.Focus();

                int ds = 1;
                if (tbx_MotoNombreDueno.Text == "") { errorProvider1.SetError(tbx_MotoNombreDueno, "El cliente al que se intenta asociar la motocicleta\nno se encuentra en los registros."); ds = 0; }
                
                int sw = valpatente * valmarca * valcolor * valmod * valrut * ds;
                if (sw == 0)
                {
                    MessageBox.Show("Los datos ingresados son erroneos, por\nfavor revise los campos señalados.\n", "ERROR EN LOS DATOS INGRESADOS.", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }

                if (sw == 1)
                {
                    int valdup = call.ComprobarMoto(tbx_MotoPatente.Text);
                    if (valdup == 2)
                    {
                        if (MessageBox.Show("La patente que desea registrar ya habia sido registrada en el sistema. Se procederá a recuperar la información de la motocicleta en cuestión.", "COINCIDENCIA DE REGISTROS.", MessageBoxButtons.OKCancel, MessageBoxIcon.Information) == DialogResult.OK)
                        {
                            int idx = call.GenIDMoto(tbx_MotoPatente.Text);
                            MOTO aux = BEDE.MOTO.Where(a => a.id_motocicleta == idx).First();
                            aux.softdelete = 1;
                            aux.rut_cliente = int.Parse(tbx_MotoRutDueno.Text);
                            BEDE.SubmitChanges();
                            Limpiar();
                            MessageBox.Show("La motocicleta fue correctamente recuperada. (se encuentra ya disponible en el panel de edición, si es que se requiere).", "RECUPERACION DE REGISTRO.", MessageBoxButtons.OK, MessageBoxIcon.Information);
                            
                        }
                        else { MessageBox.Show("Revise si la patente ingresada es correcta. Corrijalo si fuese necesario y repita el intento.", "ERROR DE DATOS.", MessageBoxButtons.OK, MessageBoxIcon.Information); }
                    }
                    if (valdup == 1)
                    {
                        errorProvider1.SetError(tbx_MotoPatente, "El sistema ya registra una motocicleta con esta patente.");
                    }
                    if (valdup == 0)
                    {
                        if (valdueno == 1)
                        {
                            MOTO aguardar = new MOTO();
                            aguardar.color = cbx_MotoColor.Text;
                            aguardar.softdelete = 1;
                            aguardar.id_marca = int.Parse(cbx_MotoMarca.SelectedValue.ToString());
                            aguardar.id_motocicleta = call.GenIDMoto(tbx_MotoPatente.Text);
                            aguardar.modelo = tbx_MotoModelo.Text.Trim();
                            aguardar.patente = tbx_MotoPatente.Text;
                            aguardar.rut_cliente = int.Parse(tbx_MotoRutDueno.Text);
                            BEDE.MOTO.InsertOnSubmit(aguardar);
                            BEDE.SubmitChanges();
                            MessageBox.Show("La informacion ingresada fue almacenada\nexitosamente en la base de datos.", "INFORMACIÓN GUARDADA.", MessageBoxButtons.OK, MessageBoxIcon.Information);
                            Limpiar();
                            btn_MotoGuardarLink.Enabled = true;
                        }
                    }
                    //else { MessageBox.Show("No se puede almacenar el registro ingresado, pues existen errores en los datos. Por favor corrija los campos señalados y repita el proceso.", "ERROR DE REGISTROS.", MessageBoxButtons.OK, MessageBoxIcon.Error); }
                }
            }catch { MessageBox.Show("Ha ocurrido un error al intentar guardar la inforación\n de la motociclera. Por favor, revise los datos e intentelo nuevamente.\n De persistir el error, se recomienda reiniciar el programa.", "ERROR AL INTENTAR GUARDAR.", MessageBoxButtons.OK, MessageBoxIcon.Error); }
        }

        private void tbx_MotoRutDueno_TextChanged(object sender, EventArgs e)
        {
            tbx_MotoRutDueno.Text = tbx_MotoRutDueno.Text.Trim();
            tbx_MotoNombreDueno.Clear();
        }

        private void tbx_MotoPatente_Leave(object sender, EventArgs e)
        {
            valpatente = call.ValidarPatente(tbx_MotoPatente.Text);
            if (valpatente == 0) { errorProvider1.SetError(tbx_MotoPatente, "* La patente ingresada no es valida.\n* Este campo no puede quedar vacío."); }
            else { errorProvider1.SetError(tbx_MotoPatente, ""); }
        }

        private void tbx_MotoRutDigitoDueno_TextChanged(object sender, EventArgs e)
        {
            tbx_MotoRutDigitoDueno.Text = tbx_MotoRutDigitoDueno.Text.Trim();
        }

        private void tbx_MotoModelo_Leave(object sender, EventArgs e)
        {
            tbx_MotoModelo.Text = tbx_MotoModelo.Text.Trim();
            if (tbx_MotoModelo.Text == "") { valmod = 0; } else { valmod = 1; }
            if (valmod == 0) { errorProvider1.SetError(tbx_MotoModelo, "* Este campo no puede quedar vacío."); }
            else { errorProvider1.SetError(tbx_MotoModelo, ""); }
        }

        private void tbx_MotoRutDigitoDueno_Leave(object sender, EventArgs e)
        {
            tbx_MotoNombreDueno.Clear();
            errorProvider1.SetError(tbx_MotoNombreDueno, "");
            valrut = call.ValidarRut(tbx_MotoRutDueno.Text, tbx_MotoRutDigitoDueno.Text);
            if (valrut == 0) { errorProvider1.SetError(tbx_MotoRutDigitoDueno, "* El RUT no coincide con su digito verificador.\n* El número de RUT solo puede contener caracteres entre 0 y 9.\n* El Digito Verificador solo admite caracteres entre 0 y 9 ademas de la letra K.\n* Ninguno de los campos puede quedar vacíos."); }
            else
            {
                valdueno = call.ComprobarDueño(tbx_MotoRutDueno.Text, "");
                if (valdueno == 0) { errorProvider1.SetError(tbx_MotoRutDigitoDueno, "Ha ocurrido un error de registros. El RUT del dueño al que intenta asociar la motocicleta no se encuentra en la base de datos.\nPor favor, registre al dueño del vehículo antes de registrar la motocicleta."); }
                else
                {
                    lista1 = BEDE.CLIENTE;
                    foreach (CLIENTE aux in lista1)
                    {
                        if (aux.rut_cliente == int.Parse(tbx_MotoRutDueno.Text.ToString()))
                        {
                            if (aux.softdelete == 1)
                            {
                                tbx_MotoNombreDueno.Text = aux.nombre;
                                errorProvider1.SetError(tbx_MotoRutDigitoDueno, "");
                            }
                            else { errorProvider1.SetError(tbx_MotoRutDigitoDueno, "El cliente que intenta asociar no se encuentra en el sistema."); }
                        }
                    }
                }
            }
        }

        private void cbx_MotoMarca_SelectedIndexChanged(object sender, EventArgs e)
        {
            errorProvider1.SetError(cbx_MotoMarca, "");
        }

        private void cbx_MotoColor_SelectedIndexChanged(object sender, EventArgs e)
        {
            errorProvider1.SetError(cbx_MotoColor, "");
        }

        private void cbx_MotoMarca_Leave(object sender, EventArgs e)
        {
            valmarca = call.ValidarCombobox(cbx_MotoMarca.Text);
            if (valmarca == 0) { errorProvider1.SetError(cbx_MotoMarca, "* Debe seleccionar alguna MARCA para la motocicleta."); }
            else { errorProvider1.SetError(cbx_MotoMarca, ""); }
        }

        private void cbx_MotoColor_Leave(object sender, EventArgs e)
        {
            valcolor = call.ValidarCombobox(cbx_MotoColor.Text);
            if (valcolor == 0) { errorProvider1.SetError(cbx_MotoColor, "* Debe seleccionar algun color para la motocicleta."); }
            else { errorProvider1.SetError(cbx_MotoColor, ""); }
        }
    }
}

